{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv(r\"public.test.csv\")\n",
    "\n",
    "df.drop_duplicates(df.columns.drop('ID'), keep='first', inplace=True)\n",
    "df.drop(df[(df.电压A > 800) | (df.电压A < 500)].index,inplace=True)\n",
    "df.drop(df[(df.电压B > 800) | (df.电压B < 500)].index,inplace=True)\n",
    "df.drop(df[(df.电压C > 800) | (df.电压C < 500)].index,inplace=True)\n",
    "df.drop(df[(df.现场温度 > 30) | (df.电压B < -30)].index,inplace=True)\n",
    "df.drop(df[(df.转换效率A > 100)].index,inplace=True)\n",
    "df.drop(df[(df.转换效率B > 100)].index,inplace=True)\n",
    "df.drop(df[(df.转换效率C > 100)].index,inplace=True)\n",
    "df.drop(df[(df.风向 > 360)].index,inplace=True)\n",
    "df.drop(df[(df.风速 > 20)].index,inplace=True)\n",
    "df.to_csv('clean.test.csv')\n",
    "df\n",
    "df.describe()\n",
    "这是我处理的噪声\n",
    "\n",
    "import pandas as pd\n",
    "origin_result=pd.read_csv('origin_result.csv')#需保留列名\n",
    "clean_result=pd.read_csv('clean_result.csv')#需保留列名\n",
    "clean_ID=list(clean_result['ID'])\n",
    "clean_score=list(clean_result['score'])\n",
    "for i in range(len(clean_ID)):\n",
    "    origin_result.loc[origin_result['ID'] == clean_ID[i],'score'] = clean_score[i]\n",
    "origin_result.drop(origin_result.index)\n",
    "origin_result.to_csv('result.csv',header=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 自定义工具函数库"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_X,train_y,test_data = load_data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 自定义工具函数库"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "#coding=utf-8\n",
    "import  pandas as pd\n",
    "import numpy as np\n",
    "import scipy as sp\n",
    "from sklearn.metrics import mean_squared_error\n",
    "import scipy.signal as signal\n",
    "import math\n",
    "# def load_data():\n",
    "#     print (\"============================读取数据========================\")\n",
    "#     print (\"======================我是萌萌哒分界线========================\")\n",
    "#     train_data = pd.read_csv('./data/public.train.csv')\n",
    "#     test_data = pd.read_csv('./data/public.test.csv')\n",
    "#     submit = pd.read_csv('./data/submit_example.csv')\n",
    "#     train_y = train_data['发电量']\n",
    "#     train_X = train_data.drop(['ID','发电量'], axis=1)\n",
    "#     return train_X,train_y,test_data\n",
    "def del_data(df):\n",
    "    df.drop_duplicates(df.columns.drop('ID'), keep='first', inplace=True)\n",
    "    df.drop(df[(df.电压A > 800) | (df.电压A < 500)].index,inplace=True)\n",
    "    df.drop(df[(df.电压B > 800) | (df.电压B < 500)].index,inplace=True)\n",
    "    df.drop(df[(df.电压C > 800) | (df.电压C < 500)].index,inplace=True)\n",
    "    df.drop(df[(df.现场温度 > 30) | (df.电压B < -30)].index,inplace=True)\n",
    "    df.drop(df[(df.转换效率A > 100)].index,inplace=True)\n",
    "    df.drop(df[(df.转换效率B > 100)].index,inplace=True)\n",
    "    df.drop(df[(df.转换效率C > 100)].index,inplace=True)\n",
    "    df.drop(df[(df.风向 > 360)].index,inplace=True)\n",
    "    df.drop(df[(df.风速 > 20)].index,inplace=True)\n",
    "    return df\n",
    "def cal_score(mse):\n",
    "    if isinstance(mse, float):\n",
    "        return 1 / (1 + math.sqrt(mse))\n",
    "    else:\n",
    "        return np.divide(1, 1 + np.sqrt(mse))\n",
    "#滤波函数处理\n",
    "def del_data_byhand_two(array):\n",
    "#     return signal.medfilt(array, kernel_size=5) \n",
    "    array_std = array.std()\n",
    "    array_mean = array.mean()\n",
    "    array_max = array.max()\n",
    "    array_min = array.min()\n",
    "    array_std_x = np.dot(array_std,1)\n",
    "    # std_max= np.dot((array1_max-array1_mean),0.25)+array1_mean\n",
    "    # std_min = array1_mean-np.dot((array1_mean-array1_min),0.25)\n",
    "    std_max = array.mean()+array_std_x\n",
    "    std_min = array.mean()-array_std_x\n",
    "    for i in range(len(array)):\n",
    "        if i>0 and i<len(array):\n",
    "            if array[i]>std_max or array[i]<std_min:\n",
    "                array[i] = np.divide((array[i-1]+array[i-1]),2)\n",
    "    return array\n",
    "# 展示数据的均值，最大值，最小值，标准差\n",
    "def describe_array(array,string):\n",
    "    print(\"------描述数组%s的特性-------\"%string)\n",
    "    print(\"array.mean()\",array.mean())\n",
    "    print(\"array.max()\",array.max())\n",
    "    print(\"array.min()\",array.min())\n",
    "    print(\"array.std()\",array.std())\n",
    "# 手动处理数据    \n",
    "def del_data_byhand_one(array):\n",
    "    array_front_mean = array[:4000].mean()\n",
    "    array_front_std = array[:4000].std()\n",
    "    array_front_max = array[:4000].max()\n",
    "    array_front_min = array[:4000].min()\n",
    "    array_behind_mean = array[4000:].mean()\n",
    "    array_behind_std = array[4000:].std()\n",
    "    array_behind_max = array[4000:].max()\n",
    "    array_behind_min = array[4000:].min()\n",
    "    std_max_front = array_front_mean+array_front_std\n",
    "    std_min_front = array_front_mean-array_front_std\n",
    "    std_max_behind = array_behind_mean+array_behind_std\n",
    "    std_min_behind = array_behind_mean-array_behind_std\n",
    "    for i in range(len(array)):\n",
    "        if i>0 and i<len(array):\n",
    "            if i<=4000:\n",
    "                if array[i]>std_max_front or array[i]<std_min_front:\n",
    "                    array[i] = np.divide((array[i-1]+array[i-1]),2)\n",
    "            if i>4000:\n",
    "                if array[i]>std_max_behind or array[i]<std_min_behind:\n",
    "                    array[i] = np.divide((array[i-1]+array[i-1]),2)\n",
    "    return array\n",
    "\n",
    "def del_data_singal(array,n):#scipy.signal.medfilt(volume, kernel_size=None)   data = scipy.signal.medfilt(array, kernel_size=3)\n",
    "    for i in range(n):\n",
    "        data = signal.medfilt(array, kernel_size=3)\n",
    "        array = data\n",
    "    return array\n",
    "def cal_dif(array1,array2):\n",
    "    return np.subtract(array1,array2)\n",
    "def add_columns(train_data_X,n):\n",
    "#     X_columns_len = len(array_need)\n",
    "    X_columns = np.array(train_data_X.columns).reshape(1,n)\n",
    "    for num in range(n):\n",
    "        array = np.array(train_data_X[X_columns[0,num]])                \n",
    "        array1 = array\n",
    "        array2 = del_data_byhand_one(array)\n",
    "        array_del = del_data_singal(array2,3)\n",
    "        array3 = array2-array_del\n",
    "        string = X_columns[0,num]+'del'\n",
    "#         print(string)\n",
    "        train_data_X[string] = array3\n",
    "    return train_data_X\n",
    "# def add_columns(train_data_X,n):\n",
    "#     X_columns = np.array(train_data_X.columns).reshape(1,X_columns_len)\n",
    "#     for num in np.arange(19):\n",
    "#         array = np.array(train_data[X_columns[0,num]])                \n",
    "#         array1 = array\n",
    "#         array2 = del_data_byhand_one(array)\n",
    "#         array_del = del_data_singal(array2,3)\n",
    "#         array3 = array2-array_del\n",
    "#         string = X_columns[0,num]+'del'\n",
    "#         print(string)\n",
    "#         train_data_X[string] = array3\n",
    "#     return train_data_X\n",
    "def load_data():    \n",
    "    print (\"============================读取数据========================\")\n",
    "    print (\"======================我是萌萌哒分界线========================\")\n",
    "    train_data = pd.read_csv('./data/public.train.csv')\n",
    "    test_data = pd.read_csv('./data/public.test.csv')\n",
    "    submit = pd.read_csv('./data/submit_example.csv')\n",
    "    train_data_y = train_data['发电量']\n",
    "    train_data_X = train_data.drop(['ID','发电量'], axis=1)\n",
    "    test_data_X = train_data.drop(['ID'], axis=1)\n",
    "    return train_data_X,train_data_y,test_data_X"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## version2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "============================读取数据========================\n",
      "mes: 0.1557159566781557\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "#coding=utf-8\n",
    "#读取数据\n",
    "import lightgbm as lgb \n",
    "import  pandas as pd\n",
    "import numpy as np\n",
    "import scipy as sp\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "def load_data():    \n",
    "    print (\"============================读取数据========================\")\n",
    "    train_data = pd.read_csv('./data/public.train.csv')\n",
    "    test_data = pd.read_csv('./data/public.test.csv')\n",
    "    submit = pd.read_csv('./data/submit_example.csv')\n",
    "    train_data_y = train_data['发电量']\n",
    "    train_data_X = train_data.drop(['ID','发电量'], axis=1)\n",
    "    test_data_X = train_data.drop(['ID'], axis=1)\n",
    "    return train_data_X,train_data_y,test_data_X\n",
    "train_data_X,train_data_y,test_data_X = load_data()\n",
    "   \n",
    "# array_need = np.arange(19)\n",
    "train_data_X = add_columns(train_data_X,19)\n",
    "# train_data_X.columns\n",
    "#------------------------------\n",
    "\n",
    "# #--------------------------\n",
    "# train_data = pd.read_csv('./data/public.train.csv')\n",
    "# test_data = pd.read_csv('./data/public.test.csv')\n",
    "# y_train = train_data['发电量']\n",
    "# # X_train = train_data.drop(['发电量','ID'], axis=1)\n",
    "X_train, X_test, y_train, y_test = train_test_split(train_data_X, train_data_y, \n",
    "                                                    test_size=0.3, \n",
    "                                                    random_state=123, \n",
    "                                                   )\n",
    "estimator = lgb.LGBMRegressor(boosting_type='gbdt',\n",
    "                               n_estimators=300,\n",
    "                               silent=True,\n",
    "                               learning_rate=0.1,\n",
    "                              max_depth=3,)\n",
    "estimator.fit(X_train,y_train)\n",
    "pred = estimator.predict(X_test)\n",
    "mes = math.sqrt(mean_squared_error(y_test, pred))\n",
    "print (\"mes:\",mes)\n",
    "\n",
    "#----------------------------------"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'string'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "string = 'str'+'ing'\n",
    "string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## version1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 281,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-17.4 -17.3 -17.  ...  24.9  25.2   0.1]\n",
      "mes: 0.14880052412923137\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "#coding=utf-8\n",
    "#读取数据\n",
    "import lightgbm as lgb \n",
    "import  pandas as pd\n",
    "import numpy as np\n",
    "import scipy as sp\n",
    "from sklearn.model_selection import train_test_split\n",
    "train_data = pd.read_csv('./data/public.train.csv')\n",
    "test_data = pd.read_csv('./data/public.test.csv')\n",
    "submit = pd.read_csv('./data/submit_example.csv')\n",
    "train_data_y = train_data['发电量']\n",
    "train_data_X = train_data.drop(['ID','发电量'], axis=1)\n",
    "# test_data_X = train_data.drop(['ID'], axis=1)\n",
    "\n",
    "X_columns_len = np.array(train_data_X.columns).shape[0]\n",
    "X_columns = np.array(train_data_X.columns).reshape(1,X_columns_len)\n",
    "array = np.array(train_data[X_columns[0,1]])         \n",
    "print(array)        \n",
    "array1 = array\n",
    "array2 = del_data_byhand(array)\n",
    "array_del = del_data_singal(array2,3)\n",
    "# print(type(array_del))\n",
    "array3 = array2-array_del\n",
    "train_data_X[\"板温_del\"] = array3\n",
    "\n",
    "#--------------------------\n",
    "# train_data = pd.read_csv('./data/public.train.csv')\n",
    "# test_data = pd.read_csv('./data/public.test.csv')\n",
    "# y_train = train_data['发电量']\n",
    "# X_train = train_data.drop(['发电量','ID'], axis=1)\n",
    "X_train, X_test, y_train, y_test = train_test_split(train_data_X, train_data_y, \n",
    "                                                    test_size=0.3, \n",
    "                                                    random_state=123, \n",
    "                                                   )\n",
    "estimator = lgb.LGBMRegressor(boosting_type='gbdt',\n",
    "                               n_estimators=300,\n",
    "                               silent=True,\n",
    "                               learning_rate=0.1,\n",
    "                              max_depth=3,)\n",
    "estimator.fit(X_train,y_train)\n",
    "pred = estimator.predict(X_test)\n",
    "mes = math.sqrt(mean_squared_error(y_test, pred))\n",
    "print (\"mes:\",mes)\n",
    "\n",
    "#----------------------------------\n",
    "\n",
    "\n",
    "\n",
    "# X_test_columns_len = np.array(test_data_X.columns).shape[0]\n",
    "# X_test_columns = np.array(test_data_X.columns).reshape(1,X_test_columns_len)\n",
    "\n",
    "# test_array = np.array(test_data_X[X_test_columns[0,1]])         \n",
    "# print(test_array)        \n",
    "# test_array1 = test_array\n",
    "# test_array2 = del_data_byhand(test_array)\n",
    "# test_array_del = del_data_singal(test_array2,3)\n",
    "# # print(type(array_del))\n",
    "# test_array3 = test_array2-test_array_del\n",
    "# test_data_X[\"板温_del\"] = test_array3\n",
    "\n",
    "# X_train, X_test, y_train, y_test = train_test_split(X_train, y_train, \n",
    "#                                                     test_size=0.3, \n",
    "#                                                     random_state=123, \n",
    "#                                                    )\n",
    "# estimator.fit(X_train,y_train)\n",
    "# pred = estimator.predict(y_train)\n",
    "# mes = math.sqrt(mean_squared_error(y_test, pred))\n",
    "# print (\"mes:\",mes)\n",
    "\n",
    "# import matplotlib.pyplot as plt\n",
    "# plt_X = np.arange(train_data[X_columns[0,1]].shape[0])\n",
    "# plt.subplot(3, 1, 1)\n",
    "# plt.plot(plt_X,array1)\n",
    "# # plt.ylabel('Field temperature')\n",
    "# #设置坐标轴范围\n",
    "# # plt.xlim((2000, 2050))\n",
    "# # plt.ylim((-2, 2))\n",
    "# plt.subplot(3, 1, 2)\n",
    "# plt.plot(plt_X,array2)\n",
    "# plt.subplot(3, 1, 3)\n",
    "# plt.plot(plt_X,array3)\n",
    "\n",
    "# plt.show()    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### mes: 0.14943249830611205"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.5"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.divide(5,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXwAAAD8CAYAAAB0IB+mAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzsnXd8E0fax38juffei2xjMDZgMKaT0DsJ6SHJkX5ccun1HEJ6SLj0ctwlpLwpd7n0SzOE0EtCCRB6Nd1UG7AxBvd5/9jd0e5qJcsNy9Lz/XxIVqsts+PVb5555plnGOccBEEQhPtjau8CEARBEBcGEnyCIAgPgQSfIAjCQyDBJwiC8BBI8AmCIDwEEnyCIAgPgQSfIAjCQyDBJwiC8BBI8AmCIDwEr/YugJqoqChusVjauxgEQRAdinXr1pVyzqMbO86lBN9isWDt2rXtXQyCIIgOBWPsgDPHkUuHIAjCQyDBJwiC8BBcyqVDEETH4a7P1qNw01FEBfkgKTwAaVGBCPX3BgCM7RaHvSWVaOAcZedqMGfzMTRwDrOJYfqEbAzIiGzWPT/+bT9+LSpFQpg/rsxLQvek0NZ8pHbh49/2Y8H243hwVGf0Sglv03uR4BME0WQ45yjcdBQAUHq2BqVna7DhUBlC/b1Rfr4WH/22X3O8v7cZgzOjMH/bcazZd6pZgl9b34CnftgKAGAMOF9Tj79f1aPFz+IMa/adgiUqADHBfq1+7feW70Xx6fPonRre5oJPLh2CcHO2Hz0DS0EhfttT2qzza+oaUN+gXTdj6a4SsZ0SEQAAuHmgBRufGo0gX8mOTI7wx4isGABA96RQzJ7SGwDA0bw1OH7bcxIAcNOAVMSH+KHhAq3lYSkoxDXvrkTfGQubfO5T32/BqNeWokFXf5XVdbAUFGLsG8tQfPo8AOBCPA4JPkG4OePeXA4AuP691TbC3RjvL9+LztPnImPaHBSdqMDbC3dj4IsLcd/nGwAA1/VNhtnEAADhAT6ac8vO1cLP2wwASI8KBGPScQ0c+OL3g+j21DzU1DVozqmuq4eloBC3fyxF63HO8eovO2EpKMS/V0mBKHcMzQAAHDtThRMVVU16npaiL6+eT1fuxwtztgMA/r3qAD5eeQC7T5zF7/tPiWM458h5ah4AYMexijYrqxHk0iEIN6T49DkkhPqj/HytZv9/1xzEn/qnOjy37FwNej47H5ufHo3nC7eL/SNfW2Zz7POXdUf+8/MBABGBkv9eEcWKqjqcqZLunxYVCEByxdTWN+Bv32wGAHSePhf7Xhwvrtdl+s8AgAXbj+Op77fA22zC+yv2AQDmbzsOAIgP9UdFdR2W7y5F3xkLseWZMaJX0Vo88+NW/N+v+23263sVR8rOIzrYF95mE778/RCe+F5yOc1etldz3O4TZ9EvXXJjfbLSOILyQvRXPErw//dHMXKTwpAeHdTeRSEIh5yqrMGbC3bhsfFdhZXsLCNeXYI9JZUAgPtGZAIAnr+sG6Z/twVbj5Q3en7PZyUB7/70L2JfWlQg9pVWau+TFQOzieH0OUnUw2QLv6ZeEvxHxnTB578fFOcDgIkx/GvJHs11Dp46hyEvL7Epx8d2hBGQGhOFX4tKMSYnrtHncpb1B0/biH18qB+OllfhwS83YM7mY7hrWAZuGmDBwJmLYDYxjM2JQ+Hmo3avWVdv7Rko4xA2XACfjke5dB74YiPGvGFrpRCEq3Hf53/g45UHcOMHa5p8riL2APDmwt0AgKt6JyE/NdxGtJ3hucu6aXoK1/dLAQCkRwdqjosI1Lp0cpPCcOjUec2xsvcHAJAQKg2A3vaxdrLljMu74blJOZp9yliAEX/5dB1q6x27WprCFf/8zWZfl7hgAMCczccAALMW78GTsjVf38ANxT4i0AdLHxkKAKitt4p5VJAvAODrOwaIfYzhguBRgg9oK54gXBUvWRmbKgTVdfViu1tiiNj28zbDZGKNGpGvzd9lsy8uxA+nKmsAAC9d2UNYq0oIpkJYgPZzfJg1oiUlQhJ89e/v0bFZAICiE2c15/VMDkNWvLXsAzMi0SlG6pU/MqaLYbkzH5/r4Kmco3DTUVw3e5X4fPNAi9jumxahObavJQI/bz1mcw21iM+e0htxcqOm9HrqGziqauvxp/4pNi6cC6FMHif4BNERWLxTioJJDPdv0nlKxMekngnw9ZJcQQ+M7AwAcKbteEvuEfRMDhP7+lqsYjcgIxJnqyV3SrCfVuD1Fn58qFXwfby0UjN7Sm+7jVlsiB98zNbj376uF0rOVgMAooN9Ncf+8sDFYvuxbzfDUlCImXN3GF/YAV+uPYS7PluPlXulSKB+aRGIDbGW/1i5NDjsYzYhMyYIfxw6bXidnATrvID4MH94m6TneHneTuw6XoE9JWdxtroOPZPDcaRM+lvlpYQ59bdpDUjwCcLFOF9jtdL14Xz2KKmoxohXlwhr+aaBFiFSCSpL2+hq9Q0c17y7Ekt3lQhxn9gjXnwfqrLc40L9hP882E87BKiP0gnwsT9EOFrnc//sz/3EdmSgD7xVgh8R6CNcUXrB7xwbjB/uHgRAGpAGgHeW7sG+0krU1jdg/cHTKD59zm45ztfUo/x8LR79epNmf8G4LOF+Gt89Dr9slQaMn7o0G7tPnBU9lVeuzsX/3dxHnOfvYx1viQjwgUnlw7r7s/XYcLAMgNSg1snXSI2Uej8XIizTowZtm8sfB0+DMaaxegApvrn8fC36pzdv1iBBGHG4zCpQ3204gu82HMHwrBh8qBIWNRVVtegzYwEAyZ8NAJbIQBwtlyzIxDCpl8AYwA1c3RnT5gAA1uxbgx5JoegaHwKTbH4r5yp4m012LfymDi4zlYk/MCNKs9/Hi2k+Hzol1Ul0kFbwASDAx/a+/1l1QET3AMCjY7vgr0M7aY4pOlFhGHkEAMkRAVi+W5q3MH/bcSTLcw36pUWgb1oE1uyTwiy7xAaL0ND8VO2kKX9duXYdP4u5W44ixM8L6VGB2HBIEn8mP2Nz5yc0BbLwneDyf/6Gy2b9arN/3JvLMVnl8yOI1kAZ6FSzaMcJu8f3kqNqFEL8vBAR6AOlc6C4hRisovLyvB2wFBSK2bIKm4rL0TM5VFi3MSG2AmvPwneGRQ8NweanRwMAzsrXmdQzweY4L9kVoowTKI1DTLBtedTOqmnjpXEBtdgDwEs/S7H8L/0suXsqq+vsij0g9TJOym6kKf0twvpmjOHJidniuJTIANH76Koad1Czf+YEdE+UXD2Ld5bgTFWdPJ7CxTXJpUMQHsoh2QWhHwTtMn0uLAWFWLJTK/7+smV9rxyCqbe8lYFDxaD+YeMRzFoshUbe9dl6m/v3TA4Trgh/A6u97FyNYfmcIT06SJRv21EpRFSZqasmJSIA94/MFD56tTjqUe+6qneyw/v/c8keXDd7lZj4pGbVYyNU12QoPSs9Z25yqIi/NzGGbolWP723mWFYVgy8TAw3qQZ59bx+ba7NPmsjov3clrS54DPGxjLGdjLGihhjBW19PyPO19RjRuG29rg1QTjNsz9ug6WgEP9cvAe+XiaUifh2SSCr5QlN+jj2iuo6RAb6IMhXEuconRWsDN4Ckqjc+98/bO6tHvy0RAYKH3Xn2GCbYxUhNHKvNIWhnaVQS8XCf/6ybnhJzo1jMjHcP7KzGDhVZgibDExhxf3k42WysZQV/74aZWAWkHzwCnGh2jw5Ss+oS1ywSvBt750RHYSiF8aLSCIjOsUEY8OTozT7lN6W5NJxg4lXjDEzgFkARgEoBvA7Y+wHzvkFUd+X5+1A79RwvDZ/F7YcPnMhbkkQzeLAyUp8+Kvkhjh2RpsuoHdKOBaqXDpKQ7DlcLkY3ByQESmE73xNHYxgDFh7wBpdEh3si5IKyW2RHmWNqU+JDBD30w+Sqgnxb7qFr2Zkdiz2vjBe9CYczQBW3FMmAwtfsf6jg3w11v6My7uhR5J13G3ZI8NQVVeP0a9LrpzbB6ehny7cUs2Dozrj0twEZMWFCOtbNC5mkwi1dJYw3aC2+poXyqnT1hZ+XwBFnPO9nPMaAJ8DmNSWN+ScY9fxCmw5XI5Zi/fg1o/W2oj9uZo6MQik5lh5FcrlH9PekrON5s1QU36+VgySlZ+rFRESpWerUSr7Ag+crERVbb3NuUfKzqP8fC2+WnsIloJC/LxF8queqKjC9qNnxAt9uOw8KuSp6urrHjp1DpXyQJq63LuPVxhGeZw4U4XTcly15hnO1WL57hJhTZWdq8HxM8a5SmrqGrC3xBo/va/U+NkA4Gy1tb7P1dRh4fbj4rv9qvPq6htQdMKaW6T0bLUQJEBbf/UNHLuPV4jrn6qswX7VpKKiExWa2Y0KO+3kLjl5thovz9shQuWOlJ0XaQEuBPqZpv3TrUJkkcXYx2zCFXmJOFJ2Hn/+ZC0mvr1CTCS8vm+KOL6y2vjvoBaVIF8vZMmTidT5cAAp7l6JbElyEBaqjqRpLiYjk90ArnKp6FHGFCICfTQunxv6aRuQlMgAzfl3D+8k3nVlcHre/Rdjxd+GAZAGoRX3jd79otCSCVOiEZOr0R1cOokADqk+F8v72owPf92P0a8vw72f23ZbFbKfnIeLXlpss7//iwsx6O+LUFJRjeGvLrU/BdqAEa8uwYAXFwEABv19Efq/KGXWy39+AfKfXwDOOYa8vAR3/HsdKqpqhR/0oS83YuDMRRj12lI8IoeG3fHv9Xjmx63oO2Mhxr25HF+tLZauO3MRJry1QnNdALjopcW4/r1VmnJvPFSGUa8vw+zl2pweAND3hYXo9dx8m/25z/6CKR+swazFRaI++r0gPUeDSmABaXr48FeXoqSiGpXVdRj2yhJRfjUNDRzdnrLWd/aT83Dbx2ux5XA5KqvrMPSVJXj06014Z+kedHp8Lka+tgwHT57DiTNVyH9+gYg+qatvwJCXl+Bu2ef81sLdGPX6Muw8VoFuT81D3nPzMfSVJaiqrceCbccx8rVlYhLR0l0lOFNVi3lbj2HMG8vww8YjNuXs/fwCzFq8BwNnSn/DgTMXYczrF2ZWNjf4pd8zPFNsK3liOsUEIT0qEBXVdSKvjEJmbDBOyo345D6SH1s/qKqelLXlmTFYJ1v7JsY0QskYQ56cpleJTFNPshraxXbpVL0/X4lYceTmaAoTcyW3j6+3VbIskZLvX4n/n9AjXghwriqirn96BO6UE64Fym6vK/OSEBbgIyJ8rsmX6qxLXDCSwm3HFMZ2k8JIlV7NpbIbymyg+EZRQ2qUcmfFB8vli3RukkQr0NZhmUaPoXm7GWNTAUwFgJSUFIPDm8amYinUaW+Jdgp5ZkwQdutm9BlxtrpOTCNfrfL1NYbi11SuoUf5TS/ZWSJylKybPhLfrJfE/ITKkg3wMWtyefxxqAzXyD/igwY9EwDYWFyuKffgTlKYm1IfTUE5p6rWaiE/8OUGfL/hCB4c1Rl3D+uE+dukWYYVVbXiR/ZbUSn2l1bihvdXo/DewQgL8MFUOUxQT/Hp88In/cPGIxoRvu3j323+VnWyObRMDpVTxOqJ77Zojst5ap6w2tYfPA1LQaH47sFR0gSkncfO4LY/DmPhjhNY/8QoFG6ybQAA4KjcS6upa7CZONSazDOYsTmokzVMUenJpUcH2g19jAryEb0xJbJmzbSRmmRfv++X6qy3LMbn5Hj/kdmxNte7dVAaLu+ViEjZT7/qsRGol681e0q+Zq7AlmfGaIRv09Oj4SvX10/3DG6VtAfPXpqDR0Z3Ec+/+enRooeRHBGAtdNHIlK28D++tS96pVgF//Op1tmv8aH+WPP4CDH+EBPih98fH4moIK27Rc+08V1x97BOCJEHnGde0R2Pj+8KL4Nezrrpo+ymblaXOy8lHGunj0RUkC/So4IQFey4DK1BW1v4xQDUw+ZJADS/Ls75bM55Puc8Pzq60UXXHVJVW4/vN1gvrySOAoBLcm1Dv8rP1+KdpXts9gtasdU1egF6yxa6HuWH+Kf+UgM4pHMT68VBuZ1JnqXvNnPOsVj26X7x+yGkT5sjGjjGmHi2mvoGDH1lCQ6XnUfPZ+eDc44FKveN2pL9Zn0xrvyXbc4SADZiX1Vbr2lELQWFWFEkCf8aVdpZAJr0v6v2ar/bcrhcLgeEj/qTlftFhkMj74KloBCdp8/FVXbK2hivzd+FHcesLkVF/MrP1+KSt1fgXE2dmNTzzZ0DNOVY/8QorJs+ElfnJyM/NRyvXJ1rt+FhjAn3l7JIh7+PGYEGWSTflfPSKygNwOW9EsV3JhMTYq9cS+lp+HiZNJOxgny9NDHnIX7eYqDYz9tsEzXUHLzMJoSrZvIG+3lrGr+oIF/RSxnSOVoIsxExwX6aHk10sK9h9I8as4lp7q8vjxp79W6v3IC0XkB8aNNmVTeHthb83wFkMsbSGGM+ACYD+KGtbpb1xM9iu19ahMZKMlphJ/eZXzBz7g48+f0W3TeNO9PUvmZncNY9d1XvJLE9XCSMcvZsrtqyPaeyuk64hPT8cdA6mKdvnD76bT/OyH7Sw2XaGHETs95WncEQkCxsNWo3kt4l4edtwswruhuWLeuJn4X7Sj+uEuVEpIgioL/I9zx02voM6w6cFqGHV/VO0qQDULP2wGkcLjsPS0GhtCDGOytRXVePLYfLDcdJGho4+sxYgLcW7sbYN5ajqlbK8575+Fw88d0W5D7zCzYfLkf2k/Owp+QsQv290Ts1At/dNQirpknhgRGBPogM8kXP5DB8fedA+HmbNX5zdRghIAk2ALvL/l2UGQXGbOtMEcfXr+3ZqlknCdejTQWfc14H4G4A8wBsB/Al59x5x3gLeHRsF82Aitp6y9XNmF2yswSv/rLT5hr22vzfikodTtpQ+OeSIrHtKLmTkiirf3oEYuXueKeYICSGSb6+O/693iYUzxEMqkEm1VMo2f0U1ItHXK7KEKif+PPMj1JQ1bhuxmKgl7uHR0uukyv/tRKAJDSANbrEiMyYYM0Anrrhc0TZuRrkJoeJCTcA8JDsulEomjFe8y78KLuPTAxYvrsU5+WBYLPJJFxHRgyS/fuA1LPoMv1nTHx7BdLlmapqJr69QjPgrDZGPl2lTfu7sbgcXWV/bs/kMIfL6G07Yu0t6GdyXpGXhP0zJ9htBD+9rR/2vThBfF76yFBNsi/C/WnzOHzO+RzOeWfOeQbnfEZb3UfpyvdKCcP+mRPQOzVCJ9jWT/GqpEhRQb4wmxjeXmQVZ3uj5Yp19+4y24FQI1762bYRAaxpYQEpDliJ/00MCxACrY9x/vvPjSeEMtQqVSVU6KJO+s5YCEtBoY2Fqk8hoaDuwo7sKvU+/H3MmvpKDPNHTqLWwsyMsY3lBoBr8pNUxwRp/l4vXN5dE6miR0mfW9fAkRjmp3FDZagGChmD3SyR6qn2BeOy4G1mqG/g+Enn018zbYT+VBuKTpwV74eloBDbjhqHARsNeAJAVpzxLE09qfKA3/s35ouW1s+7eT/j1MhA5Fvs1zHhfrjNTFtl9uFNAyyG36stPPUEi+hgX7s5ws/X1GsG/RTU63nqGfBi4+teqnPvJIf7CzeFt5mJcob4e8ESFWCYB1wd1qhmtCqqRHHLrN57UojQL9uMz/uPnHRKQZ8KFpDS4nqrLHBlXKGunovp6oDU8KqF+/6RmYa+cQAY182aoKtfeoTGj+rjZYKPasLQ4oeHiutcmpuAUFVMc3yov0bw1Xna9da+Qv/0CI2F/JeL02E2MZyqrMHdn1kjvHokhWoazYsyo0QPRs3I15Ya3mfrM2PE9jOX5uDafOuQ1k/3DEam3Djpc8vb45ZBafjmzoEYmR2LAF8zUiIC8No1PZ06lyDcRvCVCSVqd41a5NWaow5XO2EQZz5KFs4j5fbXy1TcFACEfxmwRnY4IiXSGvaVFBEgInSy4oJFOZWBrw9u7oP9MyfgjWutP2r9ghF69pRUijVH1dFD9tBHutTWN9g0dBkxQTCbVK+LXLkDZy7Ct38cFruH6RqovJRw4dvXi686X3pMsJ94dn3CLkAKZVM6Ij2SQkVYa5CvF/5ycbrmb63uHd02OB2A1QpWQhYVdxkAXJGXCMaYYYid3oCoqWvQNEzLHx1mc47Cw6M7axoiddggAGTHh2D/ScnYiAux78ZRYzYxMcjqbTZh2aPDML57fCNnEYSE2wi+4uO2RKpjaKVfl3oE37pXGuRSYpftLaygZ6A8+JuhWiZRCZtzxL2qiCH1wGCsaibj5b2SsKFYiiTRj/K31oo4Y3KsIXhvXNtTU1/K9PqCbzfbnNcpJgheZqkQtw9Os3v9iT3iNXWdERMkBnr1MdlqkUuO8BdjAdkJkntD/cjqa6ZFBeKSHgm4Y0gGVk8bgZgQq0snKdxfM4lIseKXPDwMO54bK+LJ06Kszx0h9xaURT66q1xSI7rGaMZBbh2cJv4WV/dO0vQSgn29sP3ZseJzr5Rwzd9N8q1bd5hMTKQwiHFS8AmiJbiN4CeIBFFqmZB+TLH6jH8GmfeMMvYZoUR0OJqBaIQ6QZR6UE4dxxvi74VL5Dzk1/Vt+ZwEBfUi0erw1Mt6JYqJJFlxwYaJsgDJOg719xa9l7hQP7sD2knh/prv4kP8hODrJ7SoG7VOMcFikFP5eyluqct0f5uUiACEB/qgYFyWuIYy2BoX4mc4TT0u1A9+3mbhvkuLChKx5EodPDCqM+4aloHv77LmXwkL8NGIdvfEUNTLIh0Z5KsJsVv66DDNsfGhfnYb6mE6X362nUyLBNGauI3g+3mbMaGHtmt7UnZnxIZoBeqMPEFJbVXFhfihc6ztrMC7h1kH9vy9zWLlHX2GP2VmYXiAN67oZTuZWJ2TJNaONccYw9X5ydg/c4JYQ9OI+apEV1+tPWT3uPdvzMf2Z8dqY451g8HKN47ygii+dmUyzehsbbTOC5dbwynjdCJnMjHhokmO0DaSei1cvU+a6Ka4VrbKESn69QbiDVw+B2XXyKSeCaIn0scSbnPcESVHfLi/mKimWP3JEQF4ZEyWzXR/9aeYYF/RK4wO9kWgjxmX5ibg2Uk5Nis+JYb72zQ+SgoMfV6VtpzYRRAKbvGWcc5xtLzKxg+qdJczogPFdOcB6ZEitE0twl5mk2EOEvUA7z9vyBNx0HprVXHxXNc3BWWykKSpElKpexPK9O6moBZt9aQXdTqD8d2tQjz14nSMzI61Cd2LDvbF9AldccsgCwAp06K6/AqLHhqCEHmsQ4nNfnBUZ7x+bS5SIgOEqJuYNvLE18ssRE4R+r9f1QPv3ZhvI3L6yS7Dukj+/+vkRbIVF8tw3bhAkMGkljE5cYgI9MHonDgE+nrhs9v74aNb+tocp6wyFOhjFte3l+bXW2441OX0MptEox8VJM3sfOu6XrhR9vWrH8nXywxvM0P/9Ai8Obmn5pmURuaq3kl286gTRGvjFitenTlfh/O19TaTZsZ2i8OTE7Nxfb8U+HqZ8M2dA9E9MRS9n7dOAJrQIx61cpSM4nqICPQRP0z1AO+wrBh0jgvGf1cf1Fjg2fEhqKqzugcOyNZmckSA4dJsiiA2lnPDiIk97A/QqZeUy7STwyQ+1B+3X5QuPispKK7MS9KIVXp0kAh1VZ41Icwfl/fSxsc3cNuMirUNUn0qFn1imL/NQKyvgUV744BUjM6JtZlx6Ix/e2CnKKx/YpTmsxH/vCEP/11zEBmq51M3zAq/FgxHgB0X13HZtWWUSVJv0TPGNFP7lURoI7tKYynq9LwE0da4heAr6WT1+azNJoZbVQOMSnTD0keG4V9LijCxezwuNUi50C0xFMvk0Ms+lgj8768DxfTwxDB/PKwb4H3usm74xyJp8ecQP28cKZPKo/bzR6is25p6qXFQXDsjsmI0kTvN5clLsvH1Oik3T6ZBHnPAdrKOgr7uAGnw9Pf9pw0XqKiW8+yM6xZn45opOSNZwKkR9kMN1bnLM+SQRMaYRux/uHuQ3cyPzSU9OgiPT5BWLHp8QlfkpYZpBmkV1A2U/vm6JYZi7YHThrniGxtcH9k1BmvkgWaCuNC4heArCcUSDHy7RkQE+ogfvRGWyAAoEe1RQb6NXjc3KRSnz1n9wcrMTfUEL7VfODUyEFfmJeGe4dL4wAd21ip1hm//OhBXyLNkzbpIFmeIDPTBycoadEsIwfEKbbTRezfm40RFtSbqRUEJJc1JsHVHjMmJw697SvG3cVk23ylM7BEPk4nhsz/3Q1c7k47UuczbguSIAEy9OMPp4/PkhFzTxnfFbYPTDGe0NhZMxRgjsSfaDbcQ/NTIANwxJEPk924p6thpZwbTvMwmkalQbSmH6nzDfSzhuCIvCd5mE169pnldeS7+I5GTEIL7RmTaCG+oweIURr7vdU+MstmnEBbgY+N3V1By4adEBtr44kMDvPHm5F6G5/VMDsOGQ2W4Wp6ApF68ujESQv2cTrnQmoQH+mDW9XkY1EkaPPbxMolFrfUY5WsnCFfBLQS/c2wwChxYk87yW8Fw+HiZ8A9VmgVHPDkxW3ThlZDF+FA/fHpbX81CG0rWy6/uGNjsstmTEV8vMx6QJzSds7PSEQBsfHI0zGbHYmSUBMweQ7pE45dtx9HHEi7Kpg+fNGJEVgw2HCqzG6nkiN8eazzFQVuhjwCzh8nEcM/wTpSEjHBJ3ELwWwtnXUIK6vGBUH9vlJ+vRUyw5AK6KDMan6zcD8B2IK9FcAj117sUlDh6o6n/+t6GEUrcuzNRI9f3TcGVeUkiDn39E6NsFtww4q5hnTC5b4rDpfM6Og+Ndm4SH0FcaEjwDVBW1TGK47bHa9fkYkVRqeGCCK2BM54Cxhj2z5zQ+IF2SI0MxIc35zvlZmGMaSYd6WPQ7WEyMbcWe4JwZUjwDVAs8qFdbBOX2WNE11iM6Gq7clCb0IZrXw7PukDPQBDEBcctJl65Km29KDGNDxIE0RRI8C8ArSnMRitZEQRBOAMJvgNcyYJu1YFfgiA8EhL8NoS3gU+H8zZ14RME4caQ4BvQ2m6T1rDNXam3QRBEx4QE3wGu6kZxzVIRBOHqkOA7oKWWflu5XsilQxBEcyDBvwDoc8202nXb5KoEQbgrJPgOcEWXTlvH9hME4b4w++b5AAAgAElEQVSQ4BvRSqLamuLsek0PQRAdDRJ8B7hiZAwHJyufIIhmQYLfhiiLb4/Obpv8NK7YIBEE4bpQ8rQ2JDshpEXZKwmCIFoTsvA7CEbWPLl2CIJoCiT4HQwSeYIgmgsJvgGuqam2Jj758AmCaAok+A5wRT11zcaIIIiOAAm+AW2R5bI1oZz4BEE0hxYJPmPsacbYYcbYBvnfeNV3jzHGihhjOxljY1peVALQ9jpccSYwQRCuS2uEZb7OOX9FvYMxlg1gMoAcAAkAFjDGOnPO61vhfm1OW+W+aQ3IticIorm0lUtnEoDPOefVnPN9AIoA9G2je7U6rujSceE2iCCIDkJrCP7djLFNjLEPGWPh8r5EAIdUxxTL+2xgjE1ljK1ljK0tKSlpheK0Hq4osi7YFhEE0UFoVPAZYwsYY1sM/k0C8C8AGQB6AjgK4FXlNINLGUoV53w25zyfc54fHR3dzMdwf1yw7SEIooPRqA+fcz7SmQsxxt4D8JP8sRhAsurrJABHmly6dsK1rWiXLhxBEC5MS6N04lUfLwewRd7+AcBkxpgvYywNQCaANS25F0EQBNEyWhql8xJjrCcks3M/gL8AAOd8K2PsSwDbANQBuKujROh0BFy7B0IQhKvSIsHnnE9x8N0MADNacv32xpXi3I1CRV1xUJkgCNeFZtp2MMi6JwiiuZDgG+CKmqo25l2xfARBuD4k+A4glwlBEO4ECb4DXNV9Qu0QQRDNgQSfIAjCQyDBd4ArunQ4yIdPEETzIME3wBVdOUaNjwu2RwRBuDAk+B0MV8zkSRBEx4AEv4Pgiu4lgiA6FiT4BozKjgUADMiIbOeSGENWPkEQzaE1VrxyOwZkRGL/zAntXYxGceWVuQiCcD3Iwu9gqG17svQJgmgKJPgdBFdK5EYQRMeEBL+DoTbqyaVDEERTIMHvKJC2EwTRQkjwCYIgPAQS/A5CX0sEsuND8OjYLi45E5ggCNeHwjI7CIG+Xphz30UAgEOnzrVzaQiC6IiQhU8QBOEhkOATBEF4CCT4BEEQHgIJPkEQhIdAgk8QBOEhkOATBEF4CCT4BEEQHgIJfgeGUukQBNEUSPAJgiA8BBL8Doivt/RnS48OaueSEATRkaDUCh2QmGA/fHRLH+Slhrd3UQiC6ECQ4HdQhnaJae8iEATRwSCXDkEQhIdAgk8QBOEhMFdaCJsxVgLgQDNPjwJQ2orF6ehQfWih+rBCdaHFHeojlXMe3dhBLiX4LYExtpZznt/e5XAVqD60UH1YobrQ4kn1QS4dgiAID4EEnyAIwkNwJ8Gf3d4FcDGoPrRQfVihutDiMfXhNj58giAIwjHuZOETBEEQDiDBJwiC8BDcQvAZY2MZYzsZY0WMsYL2Lk9bwBhLZowtZoxtZ4xtZYzdJ++PYIzNZ4ztlv8fLu9njLG35DrZxBjLU13rJvn43Yyxm9rrmVoDxpiZMfYHY+wn+XMaY2y1/GxfMMZ85P2+8uci+XuL6hqPyft3MsbGtM+TtBzGWBhj7GvG2A75PRngqe8HY+wB+XeyhTH2X8aYnye/GwLOeYf+B8AMYA+AdAA+ADYCyG7vcrXBc8YDyJO3gwHsApAN4CUABfL+AgB/l7fHA5gLgAHoD2C1vD8CwF75/+Hydnh7P18L6uVBAJ8B+En+/CWAyfL2OwDulLf/CuAdeXsygC/k7Wz5nfEFkCa/S+b2fq5m1sXHAG6Xt30AhHni+wEgEcA+AP6qd+JmT343lH/uYOH3BVDEOd/LOa8B8DmASe1cplaHc36Uc75e3q4AsB3Siz0J0g8d8v8vk7cnAfiES6wCEMYYiwcwBsB8zvkpzvlpAPMBjL2Aj9JqMMaSAEwA8L78mQEYDuBr+RB9fSj19DWAEfLxkwB8zjmv5pzvA1AE6Z3qUDDGQgBcDOADAOCc13DOy+C574cXAH/GmBeAAABH4aHvhhp3EPxEAIdUn4vlfW6L3OXsBWA1gFjO+VFAahQAKGk07dWLO9XXGwAeBdAgf44EUMY5r5M/q59NPLf8fbl8vLvURzqAEgD/J7u43meMBcID3w/O+WEArwA4CEnoywGsg+e+GwJ3EHyjhf7cNtaUMRYE4BsA93POzzg61GAfd7C/Q8EYmwjgBOd8nXq3waG8ke/coj4gWbR5AP7FOe8FoBKSC8ceblsf8jjFJEhumAQAgQDGGRzqKe+GwB0EvxhAsupzEoAj7VSWNoUx5g1J7P/DOf9W3n1c7opD/v8Jeb+9enGX+hoE4FLG2H5IbrzhkCz+MLkbD2ifTTy3/H0ogFNwn/ooBlDMOV8tf/4aUgPgie/HSAD7OOclnPNaAN8CGAjPfTcE7iD4vwPIlEfgfSANuvzQzmVqdWSf4gcAtnPOX1N99QMAJZLiJgDfq/bfKEdj9AdQLnfp5wEYzRgLly2h0fK+DgXn/DHOeRLn3ALpb76Ic34DgMUArpIP09eHUk9Xycdzef9kOVIjDUAmgDUX6DFaDc75MQCHGGNd5F0jAGyDZ74fBwH0Z4wFyL8bpS488t3Q0N6jxq3xD1LEwS5Io+iPt3d52ugZB0PqTm4CsEH+Nx6Sr3EhgN3y/yPk4xmAWXKdbAaQr7rWrZAGoIoA3NLez9YKdTMU1iiddEg/yiIAXwHwlff7yZ+L5O/TVec/LtfTTgDj2vt5WlAPPQGsld+R7yBF2Xjk+wHgGQA7AGwB8CmkSBuPfTeUf5RagSAIwkNwB5cOQRAE4QQk+ARBEB4CCT5BEISH4NX4IReOqKgobrFY2rsYBEEQHYp169aVcifWtHUpwbdYLFi7dm17F4MgCKJDwRg74Mxx5NIhCILwEFzKwicIomNxoqIKe05UIjshBIE+ZniZbW3ImroG7Dh2Bg0cMDOGrvHBhsc5Q01dAxgDvJt5vitSXVeP0rM1SAj1gzRPrO0gwScIollYCgpt9vl4mWBiwJicOOwtqUQD59h29AzU032euiQbtwxKa9Y9x7yxDPtKK+HjZULB2CzcOrh513El/vzJOizbVYLnLuuGKf1T2/Re7tNMEgRhF9XM0VahqrbecP+tg9JQ38Dx/YYj2Hy4HCUV1eAcSAzzxwc35QMAzpyvMzy3MY6Unce+0koAgI/ZhB3HHOUObD0OnjwHS0Ehrn13ZZPPrW/gqKtvMPyuqrYe1XX1WLarBABw8mx1i8rpDCT4BOHmXPTSIqQ9Ngdpj81p8rmcc7w2fxfmbD6q2f/CnO1iu1NMEADgL0PSUTAuC75eZgBAXkoY+lgiAABd44MxPEvKzNzQxIaHc46augasKCoFAMy6Pg8hfl64UEkCLn55MQBg9b5TaGhw/qbl52uRMW0OOj0+F2XnajTfvb98L7Ke+Bldpv8s9l2I5yGXDkG4MZxzHDp1Xnw+Vl6FuFA/p89XNxIF47Iwc+4OzfeF9w7G1E+kDNXhAT6a79YfLMO4btK90qIChX+acy7cQY+M6YK7hnUS5/zfr/vwzI/bAABrpo0AB9DvhYWa6w7tEo0ZhcBX64rhZTbhxSu6O/08ztLQwPHUD1vx8Jgumv21DQ3wNZntnqc812e398P1768W+1cUlWJijwQAQGV1HZ4v3G5z7oVov8jCJwg3o6KqFmPfWIYv1x7CzuMVmu/+varx6L1PVu6HpaAQD365QbNfL/YAkJMQKqzXCFnwz1ZbXTbHzlQBANKipF6AiUFY6gDw8rydOF9Tj5V7TmLRjuNC7AHg+vdX24g9AAT6euFIuXTd/645iL0lZxt9pqaSPm0OPl11ALnP/KLZz7nkWqqrbwDnHLMWF+HQqXOorK7TjGmoxR4ATldaLfycp9ov+ahHCX7XJ37GrMVF7V0MgmiU5btLYCkoxJp9p5p8bvenf8GOYxV49OtNGPvGcgDAskeGITbEFzuOVTRyNvDk91sBAN+uPwwAGJMTi9zkMJvjrsiTFn+qrJH8+WEB3prvZ12fJ3zuaVGBAAATY1h/sExz3NoDp3Dde6tw60drNccWnXBOyD9Z6VQIutN0NxDkqCCpMct64mcMnLkInR6fi82Hy/HyvJ246KXFdkX8klzJqq+pt7Xfr+ilWzzrAvh0PErwz9fW4+V5O9u7GATRKM/Klu4d/17XyJHOkRTuj9TIQJytrnV4nNFg7JicOOxUDZBe3y8FAJAQ6q85LjxQ69KJC/VD2TnpfhnRkoirJW2m7IqZ8oE2xfyTl2Tj09u0S8feO1xy+3SND7Ep30e/7cevql5DS6moth1UvlwvzgAu/cevDq/z/o35+PuV0jOqB27TowORHh0o6hEA2jgaU+BRgk8QHYXEcElMh3ZudLa8BvXg4ID0SADAlXlJMJkU/7nj80e9vtRmX3p0EKpqJcH64e5BqJIt+mA/7RCg3oefEGYdK4gO9gUgRa0o+PsY+8JTIwIQ4GO99ktX9sCZKkmEr+qdZHjODe+vRkMDR/m5WrsRRI5QxhXUbplHVP77iEBfsW1iQL+0CMPrLH1kqNhODPcX8wV+3y/11M5W12F/aSUu6ZGA87pykg+fIDwQzjmW7Cxp1rn7T54DALx0VQ+cqZKs667xwQCkFU8aExVlgPevQzPEPuV8AEgKDxDiG+yndeGE61w60UFWkdRPKNr41Gi7ZYgP9YePamLVpT0TUFIhhSwqDYdC0Yxx6BIrlS992hzkPvsLsp74uckhqPoIpnen9IZZbiSHdI7Gwu3HAQBjc+LQwKWIHQC4Y0iG5rzk8ACxHR3sCy/5Ggu2n8B/Vh/ApuIyNHCgZ0qYeKYB6ZHS3+YCKD4JPkG4GCdVA3yVNXX47o/DqK5zbLX2evYXWAoK8ansz+6VHIaj8sBmQpjUW7DnNth4qExYtxN7xAMAImWxDvAxizBLAAjz9xZuIb2FH+qvFXxHs2lD/b01jcCmp60NgL+PGT5e1nP9vM3YfLgcgNWXrr7HP67vZXP9r9cV48DJSnSePhf9X1io6VmoeXfpHk2IqUJ6VCBkrUZdQwNK5Rj5WwZZNMflp4bj/27pIz4rPSlAqiv1Mz7+vy3YcEgav+iZFAalSPEXYIatKN8FuUsH58EvN+DRrzfa7H9hznbc9tHv7VAiwp0pPm0No5y39Tju/2KDJl5bz0+bjuC07Cv/Zn0xzCaG5IgAnJIbDkXwAQgTv6GBo7quHpxzTJr1q+paRzEwI1KIXWKY1k9vMjERhaMXfGfSJXRPDMX0CV01+3KTQhGi6y14m7UCqLg/9OMGgHFDtvXIGQx5eQlq6hpw7EwV+r9oG+3z8rwdeHHuDsxettfmu6TwAFGnm4vLYZJvEhnkq+n9dI4Nxlm5xzOya6zmGkp93KaaDfz9H0eQEOqH8EAfay9ELj+/AE4dEnwn+Hb9YXy5tthm/+xle7Fwx4l2KBHhzhw6dc5w/+q9J/HbnlKcq9EOKt792R+az2H+3vDztlrlimgzMHBIQp8+bQ66TP8ZWU/YNiS9U8OFwJkM1LTCjkvHGX68ZzBuvygdAHBAjuDplRJuc5xybcVnr2hjgK+t319tHa+bPhKANJCrpqSiWvRiys7V4KdNRzBr8R7NMZP7JIttfx+zCKV8eEwXMVnMxIB7hmeK4yKDfFB2XmoY8lJtI5kA4ImJ2XhiYjYAYOfxChFSqsg7A3Mflw5jbCxjbCdjrIgxVtDW9yOIjkptfQM2FZeJlAERuqiXa2evwvXvrcabC3Ybnv/YuCwAtpZ3pHwdRRevf88aI15dJw3Gdk8MFftyEkLEsbnJ1v0Kp85KQqj20TeHEtlNkhRua7VHB/tixd+G4eWregCAsIaNGiD1HiPXiH5Xz2fn2zSSAPDC5doJXIfLpJ5WTLCvEGcTY5rBZhNjuCY/CU9MzMaf5YbMiBv6paCnPrSVK9dwkygdxpgZwCwA4wBkA7iOMZbdlvc0YsXuUsNETwThKnDOkfn4XFz6j1+F5am4ZDrHBmmOXX/wtNhWwv2ignyEGMaH2rphFGrqOdYdOA09X90xQGwnhQcIK14feQNYwxYjgmy/awr3jsjEzQMtmDJAShi29JGhWPG3YZpyKALe4Ejw5X0hfl4w6b7e8dxYYTmbTUyEhyoseXio2DbpTp56cToiAn0wICPK5v6Ky4kxwNfLjNsGpznM4OnnbcZ3dw3S7FOuyYRLp+1p69QKfQEUcc73AgBj7HMAkwBsc3hWK1BVWy+6qzHBLbNELiSV1XUI8DFfsEEcwjV4/Lstdr/LSQjFruPWSUhHyqrQ0MCRPm2OCL18eHQX4VsvLjN2CTEmDdAqDM+KwSLZJamOirFEBeK/aw4C0Pn/dQR4208x4AxRQb54+tIc8Tk1MtDusQ0qa1hPjdxLiQ72lZ0jElufGaNxbW1+ejSOlFVh5GtS6OkHN+WLSBw/b+n5cxJCYJEnfl2UGY31T4yS7i+H0et/li35mWpdOu4xaJsI4JDqc7G8r804XVmDZ3/chhW7rRMxTlRos9BtOVyOd5fu0Z+KL38/hBW7S8E5xyvzduLgSeMfjhG/7SnFZ6ulH8mK3aX44ndp++ctR1G4SUo8NWtxkWGGv/+sPoBVe0/CUlCInKfm4br3VuHkWcnnmPPkzyK87pOV+0U8b+Gmo/h5i3Td95fvxcZDZZpy19U34Lmfthlm4PvfH8VYbDD2sHRXCXKf+QUnKiQf47JdJfhy7SGb4wApg+Ar83aKLIyvz9+FPXamuK/eexIfrNgn1VOR1Nuqb9CepyTpuv3jtSJB1c9bjuGnTUfEdd5euBs75ZmiJyqqMKNwG+obOJbsPIF3l+4Rro6GBo4X52zHMdlXqnC+ph5P/7AVlQYTa57/aRssBYV45CtpcP7fq6S/yYVCeXcUbh5oEduKDz42xBd3DMnAiYoqpE+TwghXymXslhiKGtnajw02zpWjFpXPp/YX78aVeUka4Qry9cIR2Z1h5G5R0FvEbYnVGra9p/L7CNP1RgJ9tfZsgI8X6hqsE6CGdYkRg8FKHRfeexFmXZ9ncw/hUmrFZ1Z6HiaT9nNb0tYWvlHtaB6LMTYVwFQASElJMTi8aTxfuB3frC/Gh7/us3vMxLdXAAD+oouhffSbTQCARQ8NwT8WF2H+tuOY98DFTt1X8Yte3y8Ff/pA2r62Twru+Pd6AMD47uPx8rydeHPhbiSG+WNARiSen9RN/HDVrNp7Cr2fXwBAmrb+4pztePGKHmLK+/6ZE3DXZ+vFtpKISV3u+0dm4oMV+1BSUY23rtOGrT3wxUZxrpqbPpRmPE7/3xbMvjEfN8qfr8lPxsZDZbjt47X48Z5BiA/1x58/WYudxytwRV4iQv298ebC3fji90NYNW2E5ppbj5Tj2tmrAEjRCkqOkYXbj6N3arg4T8m5AgCbDpfj2R+3iin4E3skoLquHq/O34V3l+3FlmfGoOCbzVi04wT6pkXiz59Yl8XsYwkX99h65AzuG5mJq99Ziat6JyEjOggf/bYfIX5euGmgBQu3n8A1fZJRUVWL9+UG6at1xXj56lxMly1ufR21BUYThe4bkSkGHmtlIY8I9EVYgDdqDabpZ0QH4et1UmDB2G5xAIDnJuWg/Lx1Zq2S5gAA+qdHYmOxFOqYGhlgI6SPT+gKfx8zBnWKAgA8f1k3MYj54c35WLjdajA8PLozQlVie/NAC/rKE5NevzYXO442ns6hMT64qQ8+XrkfwbKI3zk0A+myJd4jKRQju8bib2O7wFe21NWRQO9O6Y2UCCk+Pi0qEGNz4vDni9NhMjGkRQVifPc43DsiE46YdUMe3l26F3EhUmP66W398Nnqg5qekcIzl+Zo8gmp+evQDKRHSy66ibnxmLvlKO4ZnontRysQG9L2noi2FvxiAMmqz0kAjqgP4JzPBjAbAPLz81vcxtXayT19Ve8k8YNoDKX7aO9azUG5Zk1dA/aVVmJfaaWIeW4MJbdIYyiVV1vfgHrZXLAXf+wIo1Om/W8zSs9W48EvNuJv47JEUi7GmDi+rqFBjJVc0SsRr13bE1e/Y5xDvLaei0ZNLfYAcNks2ynrXFV/gDV3uFrsAW3SqnM1deL+X68rxl8ulgbV6rn13nGhfvjnEvv5lU6ercbzhdvx0OjOSFJNqmlNni+UPJxqF0t4oA/uH5mJI2Xn4Su7Jf58UZpIVaDH38csemYxsihNGWDRHKMMQr56da5mvzqcMF7OpNkpJhj/vKG32P8n1cIcw7NiMTzLes7dw7ViqXbTXN4rCbANk28yfdMiRCMCAH8bmyW2fb3MeF/OtQ/YNtJjcuI0x74zxfpc3maT5jnt0SslXHNe//RI9JfdaXpuUvXO9DyqKneInzc+va0fANj499uKtnbp/A4gkzGWxhjzATAZwA9tdbN1B07jh43W9kQ9IWJghu0f59p3V8JSUIgTOsERtGKP1WjmnzpawogCOerCkW9Te4/Gj1H8l47QGy1nq+uw9YjkitpTclYjyNLsTenGpWetE4a+/eMwqmrrca7Gar2qMwYqPRQ19qarby4ux41yvpWaeqlRUaxTR+iTdCmzI5U0AYDkxlLcRBN6xNvEnfd+fgH+98dhDP67lBN9RuE29H9hoVPGQFVtPSwFhbjnv1JEyImKKlw3exXqGzgW7TguXEjKxKY3J/eEJTJAuHPuH9kZL12Viz9flIZv7hyIK/KSNBOSnpuUo7lftfxcihVqD31eGGVQ+POp/fHjPYMbfS6i49Kmgs85rwNwN4B5ALYD+JJzvrWt7nflv36zbuclIUjlw0uNtFpnisWsCMCNH67B+Rrn82/U1jc0Oepn6S7npsrfqZrUMShD6k432Uq301BtKi6zm4HwrYXWUD8lQkNh8mzJSg7197YZDzExZje8YMoH1gYtyNcLvZ6bb7fIMcG+uNJOnpRL/rECa/YbZ42MCvJFQqgfxne3WnHjusVpjvnP7ZIVpcxynLf1mPhu6a4SnD5XCxMDgn21Pl49X649hPeW78OxM1XIfHwuFm6XRHvrEdvG5/iZKhE08OPGI3h/+V70nbEQK/eeRN5z80VmyK/WFeODFfuQGhmAYD9vLHlkmMZCBqSY9N6pUqy6+j29NFcr3M9d1g33Du+E/FTbuHZAcsW8Obmn8ENPkHuYygSh/umRiGphqCXh2rR5HD7nfA7nvDPnPINzPqOt7wdIAzAzLu+m22tVQb0F5G02oeuT6gkoxgp2qrIG/11zEO8ssR3wNULdKNz28VrDY3omh4mBsRFZMSIKITc5TEQO/PU/651sYBw3DPr4bXXv5rX5u8R+vYtly2HJutcLKSBFKejbo9ly1/f3/VL43xW9Eu36NBUyY4M07dTHt/a1e6ya0rPV6BQbjDzV5B19V3tQpyjNoKQyk7V7YqhoABu4FLZn1LhOlV1Bj369SbNf+ZtOeGuF2Le/tBLl52pt8rirF7xQ+9UVusbZZoE0Ypc6v72uYU8I88eDo7vYHVgcnhWLST2tjcSs6/MuyBgF4Tq4zUxbZaT+/pGZ+LVgOPy8zXY9MuoVf7LigkWeDj0MwLoDVssy77n5eOzbzXhVJY7NoVeKdQLGHUPShRglhPmLSIpQ3WxJZ5i39bgot5qNh8rQ0MCxxcAS7fvCQptInj/1s11IeWiXaHipprs/NKozAMl3rJ4SHhnoA2+V2yHQx2wzgUhB7ZLonhimGTgc0jkaF2VGGZ4HQJM/xc/LpDk3XRVrrVxD7+7y9zZjTI7VD730kaHwMjGcqdIuZJEZE4TbdQtl32qwAPef3l8NS0Ehhr6yBLnPWhfN0C9KraTLBYCUiABhuXeOC4YzTBmQCj9vE1Y9NkK8N0YpgwnCCLcR/O83SL773CSrmKqtOvV2TCOj4ZXVUrd5T0klrvyX8aBjsMpdpLYKnbHE1bMak8IDcLxcEtwGzkU5Q/y8kBwRgI9v7YtFDw3RiJO9eyi5/jkHftsjhesVbj6KSbN+Rfq0OTh+xniR5Ft1+YBC/b1txhwm90mGl8n6uiiLXbyzZA8GvLhI7O+VEqZpcJ6Z1M1wEBgAMmOtIpebZDujUy3i254dI7b/cnG6yF8CAOO6x2nuqR7kfkBumBSUuOsBGZHi+mEB3kiNDISX2SQGhRXSowM1LejIrjGIVE04UrI3rrCTj/2x8dZBum/uHKDJGfPNnQNF6KgSRdIYPZLCsOO5cYgL9UOInzfenNzTJnc8QdjDbQT/hw3S6jx9DQb+fL1MGkHwVY1KGq0ANMkgSkTPkC7WPOUZBqGVetQipE6hmhjmL+Knx3ePFyF6ilU8pHM00qODML67cxE9ALC3tNImrlshSBeb7OtlEgOgStTQdxsO26SL7RQTLFK99k4NFy2oEs6o0CslXCPUnWKCRPSIfup6vKqnZTJZo8SVAXb130ydHz0jOkjUz9vX9cJlPROFK8zf24xA1bG95OnsV/RKxP0jM/Gg3ACoBVapW70rCwAeHNVFE78e6m8V+7yUMPx4t3aQ85s7B4rtWdfnaWaG9kjS9mKig3010/ebw6SeieR3J5zGbQRf8RdrJ1tIP67YEOP0o9f1tcb9OxsWpfix1YPAznDjAGvXPlYldOpl4Xqnhgt/eWwjkRZN4Zs7rdPm7x1hXTB6zeMjkBFtnbavhLot321rrVoiA0Tvo4/FOJoGkFwo6ppOjw4UPnP9JB71Mw7rEiMGTPXip49PTo0MwKjsWCx5eCguyU0AY0z4rVNV5QSsvYTXru2J+0d2FgKbFhUoJngpaX2Vwc6vVWkGLFHav/PNAy3i+jkJofBVua+mT+iKnASreyU+zHasSDlXn+bX4mQkFkG0BLcR/O6JoeirEyKlex4T7KsRISVGXS0slsgAm5wlgNYijgryEWMF+i642soyCouLUc1+VN9X3RD5eZvxyjW56J8e4TCW94Z+zk9Qm9wnGb1TrfWiFviYYD/hl8924AeODvaFl9mETXJPoEdSqKY+r8yzRtfo87iE+HkLkdULvpdqcNHHy8w1IVgAAA8mSURBVCRCP/1lC71CrutR2dq0s4nh/mCMiSnwgDrvTLDDaer7SqTJR5aoQJETRnGz3DIoDUUzxiFf9R75epk1DUhKZICYqRsV5KtJpHWbztefGOZvM/Vecf/l6TJEJkfYn9FKEK2F2wh+SUW1jdWtZOOLCfHV/PBOyvHiagsz1N/b0Nd8/0jrpBJ/H7NYpSZZNwmnf7okEsO6RKOfvK3OWqheqcdRFzwxzB+fTx1g43pRc5+qTGp/vhLVA0iW9v6ZEzDzyh6ac/UrBimcrNT699XzFu6R1xOd2CMeJia5mdSoQyIjA31EXfvLg85KXHljE5cOyz0Bi/x3VOLoL+mRoDnOqPej/O0m9ogXIvysLk4dAE7LSwBGBfmgXJ7EpF64wyinu1qzQ/y8UFohXyPYB37eZnx9xwBsfGo0GGPasaJgX5jlHUq9KxOn9EnJKHcScSFo65m2F4S6+gacqKjSRN8AEFOvL+mRgIQwf2REB+JvY7PwwBcbAEir+SgwxoSVyJg1qkMt2nPvuxhvLtiFXcfPiunRCoq49UgKE/lNUiMDhItGbdXrF3dwBkUQHFmCeSnhYrDW3izAmGA/rH9ilPB5n5AHcm8frE3t+uHNfTDuzeXYV1qJzvLg6pQBFlydnyxFQKkeQZl+Dyi+eKt7BQDuGtYJUy9Ot8kmqBe5aRO6orKmDjfoIltydWlljbIS3tAvBX7eJozoGguzidkNN+yZHIYdxyoQHeSLo7LP3sh/PqF7vBh3UZeTMSZWP1IabnWPQN27YIzBy8zwzxvykG+RLHrFYIgKlgT/y78MsMlvTxBthVsIfsnZajRw2Ah+t8RQbH56tFhMYeFDQwEAV+cn46Pf9qNTTBA+n9pf/EQVwU+LDMReOe9IckSAaACCfL0wbXxXTOlv0dxr6sXpKD4tJVoL8fcWSddSIwKF4Ksta0UU7IUrOkIdhaTnpoEWIfiZMbbuKaUcZpUrRRmo7BofohFxP2+zyL3SWRVNo4SKqoN4zLq4b8Xtpbbo9SIdHuBt43jJiA7C51MHqM5hqK3nToWnxob44a9DOzV63DOTcnDzIAtiQvyQnxqOZbtK0N0gQmjWDdYEWvpyKi6q+FDbnoaRoa4ecJ/cNxkbi8twm9zAGgUZEERb4RaCr4S2Gf0AjVblefrSHDw6tosm8kNNbnKYEPyucSHY+8J48R1jDCk619Ftg9Pw0JdSQrIQPy8houryqAeTFVEYnhUDQJpkFNkM8QeAV67OxcNyhsfBKku7kx3B14uzglHP4bnLuuH95XsNGyZF1KdenG4jiEpCqcGdjHsZgLRknVIPareZmu3PjhXjLa2Fr5cZWfIkp78OzcDkvsma8RUjRBpbubxPX5qDF+fuENdR01jfLTbEDx/e3KeRowiibXALwd8jD8Q5m3MGgF2xB7Q+3bAA70b9q7EhfqKbr47R1vc4AMn1kxwRgK/uGCBWwNH7xB2hlz97+WeSnYzr/uiWPth1vAKpkYHCclWY0j/VZuKQwtEy++6QEV1j8PnU/oZl6xQThKITZ/Hm5F5gzL7rBZD86W35gnqZTY2KPWAdG3l4dBcAkrvseztRXeSLJ1wZtxD8K/MS0ccSbjOQ2lSu65sCf2+zyL0NOP8DPip6Gf5IiQjAwVPnRKIrJWrn/RvzkS2H7TkKbTRCUwqV6ieF+2PPC+PBAFTVWfOs6F0o9wzvZJMvHACGdonB0C4xTSoLAJEv3agnwRizO4agDEY3J3b89Wtz0S3B1v3S1gT4eGHvC+OdWuxC6UDZa4gJoj1xC8FnjDXJurfHi1dIE4Oe/sG5/G4LHhwiQguV/CgJof74/q5BOFNVKxKmjcyOkf8fa3yhpqAz8RljUMaAjZZ/U3hItk4dYZSX3R5PXZKDxHB/DO4UBbOJ4ZLcBFybn9zoeS9c3h0zf96BbolNTwdweS/j5GoXAmcXvmCMYf4DFyPRwcIhBNFeuIXgtzaOhFON2rod2iUaS3aWIMTfC4wxhAf6AHAuQ6YzaIokJu9orWQ/bzMKxmUZJjlzhqhA6XrKwtGOSIkMwLOTrAnq3r7OuaTn2Qkh+MTJxGgdFXXKCIJwJUjwDVBcMbcMsjh9zstX5aL49DmNC0jxDLXGepXOjl3eoVvFqymEBnhT9kSCcGNI8B3QFD9zdLCv3UlNrc6FWN6eIAi3w21m2rYmrhhoYVQmVywnQRCuCwm+Aa0V+q2kGG5NYeZk3hME0UxI8B3gSha0ehyAJJ8giOZAgt/BUPc+XKg9IgiiA0CCb0BruU3ElPxWuJZRb4MsfYIgmgIJfgeELHuCIJoDCX4HhCx7giCaAwm+A1o6YUpMvGrF0V/y4RME0VxI8DsIJO4EQbQUEnwjXNhnQnH4BEE0FxJ8B7TUE6MsEO7lZKZFZ8vSymuCEAThIVAuHQe0VFivyU/GgZPnNIuOt2ZZXGliGEEQrg8Jfhvi523GExOz2+z6ZOkTBNEUyKXjAFeyoF2pLARBdExI8A1wZcNZE5ZJjQBBEE2ABN8BrqWnrlUagiA6HiT4HQxX7n0QBOHatEjwGWNPM8YOM8Y2yP/Gq757jDFWxBjbyRgb0/KiEgoUi08QRHNojSid1znnr6h3MMayAUwGkAMgAcACxlhnznl9K9yPkGmNtXIJgvAc2sqlMwnA55zzas75PgBFAPq20b08AhqgJQiipbSG4N/NGNvEGPuQMRYu70sEcEh1TLG8r0PAXTjA3YWLRhCEi9Oo4DPGFjDGthj8mwTgXwAyAPQEcBTAq8ppBpcylCrG2FTG2FrG2NqSkpJmPkbb4EpWtQsVhSCIDkqjPnzO+UhnLsQYew/AT/LHYgDJqq+TAByxc/3ZAGYDQH5+vkvYr2RFEwThjrQ0Side9fFyAFvk7R8ATGaM+TLG0gBkAljTknsRBEEQLaOlUTovMcZ6QnLX7AfwFwDgnG9ljH0JYBuAOgB3daQIHVdy5RhBPRCCIJpDiwSfcz7FwXczAMxoyfXbC9cWVGvhXL1hIgjCtaCZtg5wpTj31lwmkSAIz4QE3wBXNvBdu/dBEIQrQ4LvAFcyqtVFIc0nCKI5kOA7wBWtaRcsEkEQHQQS/A6IC3U8CILoQJDgO8CVXDoEQRAthQS/g6BufMitQxBEcyDBN8AVffcK6sRu1AEhCKIpkOB3EMi9RBBESyHBN8DbS1JXs8k1VdaV0zcTBOG6tMaKV27HPcMzUV/PcV3flPYuikNo9i1BEE2BBN+AIF8vTJ+Y3d7FaBSy9AmCaArk0ulgcJBlTxBE8yDB7yCoE7mRZU8QRHMgwe9gqLWeLH2CIJoCCX5HgbSdIIgWQoLfQQj19wYAJIX7t3NJCILoqFCUTgchLyUc707pjSGdo1FSUd3exSEIogNCgt+BGJMT195FIAiiA0MuHYIgCA+BBJ8gCMJDIMEnCILwEEjwCYIgPAQSfIIgCA+BBJ8gCMJDIMHvwFBmBYIgmgIJPkEQhIdAgk8QBOEhkOB3QCKDfAAAtw5Ka+eSEATRkaDUCh2QAB8v7J85ob2LQRBEB4MsfIIgCA+BBJ8gCMJDIMEnCILwEJgrrY/KGCsBcKCZp0cBKG3F4nR0qD60UH1YobrQ4g71kco5j27sIJcS/JbAGFvLOc9v73K4ClQfWqg+rFBdaPGk+iCXDkEQhIdAgk8QBOEhuJPgz27vArgYVB9aqD6sUF1o8Zj6cBsfPkEQBOEYd7LwCYIgCAe4heAzxsYyxnYyxooYYwXtXZ62gDGWzBhbzBjbzhjbyhi7T94fwRibzxjbLf8/XN7PGGNvyXWyiTGWp7rWTfLxuxljN7XXM7UGjDEzY+wPxthP8uc0xthq+dm+YIz5yPt95c9F8vcW1TUek/fvZIyNaZ8naTmMsTDG2NeMsR3yezLAU98PxtgD8u9kC2Psv4wxP09+NwSc8w79D4AZwB4A6QB8AGwEkN3e5WqD54wHkCdvBwPYBSAbwEsACuT9BQD+Lm+PBzAXAAPQH8BqeX8EgL3y/8Pl7fD2fr4W1MuDAD4D8JP8+UsAk+XtdwDcKW//FcA78vZkAF/I29nyO+MLIE1+l8zt/VzNrIuPAdwub/sACPPE9wNAIoB9APxV78TNnvxuKP/cwcLvC6CIc76Xc14D4HMAk9q5TK0O5/wo53y9vF0BYDukF3sSpB865P9fJm9PAvAJl1gFIIwxFg9gDID5nPNTnPPTAOYDGHsBH6XVYIwlAZgA4H35MwMwHMDX8iH6+lDq6WsAI+TjJwH4nHNezTnfB6AI0jvVoWCMhQC4GMAHAMA5r+Gcl8Fz3w8vAP6MMS8AAQCOwkPfDTXuIPiJAA6pPhfL+9wWucvZC8BqALGc86OA1CgAiJEPs1cv7lRfbwB4FECD/DkSQBnnvE7+rH428dzy9+Xy8e5SH+kASgD8n+ziep8xFggPfD8454cBvALgICShLwewDp77bgjcQfCNFvpz29AjxlgQgG8A3M85P+PoUIN93MH+DgVjbCKAE5zzderdBofyRr5zi/qAZNHmAfgX57wXgEpILhx7uG19yOMUkyC5YRIABAIYZ3Cop7wbAncQ/GIAyarPSQCOtFNZ2hTGmDcksf8P5/xbefdxuSsO+f8n5P326sVd6msQgEsZY/shufGGQ7L4w+RuPKB9NvHc8vehAE7BfeqjGEAx53y1/PlrSA2AJ74fIwHs45yXcM5rAXwLYCA8990QuIPg/w4gUx6B94E06PJDO5ep1ZF9ih8A2M45f0311Q8AlEiKmwB8r9p/oxyN0R9AudylnwdgNGMsXLaERsv7OhSc88c450mccwukv/kizvkNABYDuEo+TF8fSj1dJR/P5f2T5UiNNACZANZcoMdoNTjnxwAcYox1kXeNALANnvl+HATQnzEWIP9ulLrwyHdDQ3uPGrfGP0gRB7sgjaI/3t7laaNnHAypO7kJwAb533hIvsaFAHbL/4+Qj2cAZsl1shlAvupat0IagCoCcEt7P1sr1M1QWKN00iH9KIsAfAXAV97vJ38ukr9PV53/uFxPOwGMa+/naUE99ASwVn5HvoMUZeOR7weAZwDsALAFwKeQIm089t1Q/tFMW4IgCA/BHVw6BEEQhBOQ4BMEQXgIJPgEQRAeAgk+QRCEh0CCTxAE4SGQ4BMEQXgIJPgEQRAeAgk+QRCEh/D/AwDH1YZcK/uhCAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt_X = np.arange(train_data[X_columns[0,1]].shape[0])\n",
    "plt.subplot(2, 1, 1)\n",
    "plt.plot(plt_X,array1copy)\n",
    "# plt.ylabel('Field temperature')\n",
    "#设置坐标轴范围\n",
    "# plt.xlim((2000, 2050))\n",
    "# plt.ylim((-2, 2))\n",
    "# plt.ylim((-5, 5))\n",
    "plt.subplot(2, 1, 2)\n",
    "plt.plot(plt_X,array1)\n",
    "# plt.xlim((2000, 2050))\n",
    "# plt.ylim((-5, 5))\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt_X = np.arange(train_data[X_columns[0,1]].shape[0])\n",
    "array3 = array1-array2\n",
    "plt.subplot(3, 1, 1)\n",
    "plt.plot(plt_X,array1)\n",
    "# plt.ylabel('Field temperature')\n",
    "#设置坐标轴范围\n",
    "# plt.xlim((5889, 5892))\n",
    "# plt.ylim((-2, 2))\n",
    "plt.subplot(3, 1, 2)\n",
    "plt.plot(plt_X,array2)\n",
    "plt.subplot(3, 1, 3)\n",
    "plt.plot(plt_X,array3)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n",
      "[14. 19. 19. 59. 59. 50. 34. 50. 34. 34. 34. 34. 36. 36. 39. 59. 65. 65.\n",
      " 65. 35. 16. 16. 81. 81. 79. 71. 54. 52. 25.  6.]\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "import scipy\n",
    "# def random_int_list(start, stop, length):\n",
    "#     start, stop = (int(start), int(stop)) if start <= stop else (int(stop), int(start))\n",
    "#     length = int(abs(length)) if length else 0\n",
    "#     random_list = []\n",
    "#     for i in range(length):\n",
    "#         random_list.append(random.randint(start, stop))\n",
    "#     return random_list\n",
    "# random_list = np.array(random_int_list(1,100,10))\n",
    "# print(random_list)\n",
    "# data = del_data_signal(random_list)\n",
    "# print(data)\n",
    "# import numpy as np\n",
    "# df = np.arange(100,0)\n",
    "# df\n",
    "# array = np.random.randint(1, high=100, size=30, dtype=np.int32)\n",
    "# print(array)\n",
    "# # data = del_data_signal(array)\n",
    "array = [40, 14, 19, 59, 89,  5, 50, 34, 61, 16, 34, 45, 24, 36, 39, 59, 87, 65, 35, 74, 7, 16, 81, 85, 79, 71, 54, 52, 25, 6]\n",
    "print(type(array))\n",
    "# scipy.signal.medfilt(volume, kernel_size=None)\n",
    "data = scipy.signal.medfilt(array, kernel_size=3)\n",
    "print(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(9000,)"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# train_data[X_columns[0,1]] \n",
    "train_data[X_columns[0,1]].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'光照强度'"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "for id in np.arange(X_columns_len):\n",
    "        deal_column = train_data[X_columns[0,id]]      \n",
    "X_columns[0,2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
